.github/skills/cuopt-user-rules/SKILL.md-137-137 (1)

137-137: ⚠️ Potential issue | 🟡 Minor

Fix typo in installation prompt sentence.

Line 137 reads “do you have access another way?”; this appears to be missing “it” and can confuse users. Suggested: “...or do you have access to it another way?”

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-user-rules/SKILL.md at line 137, Update the prompt
sentence in SKILL.md by correcting the typo in the quoted string "Would you like
help installing cuOpt, or do you have access another way?" to include the
missing words—change it to "Would you like help installing cuOpt, or do you have
access to it another way?" so the user-facing prompt (the quoted sentence in the
file) reads clearly.

.github/skills/cuopt-qp-api-python/assets/portfolio/model.py-33-35 (1)

33-35: ⚠️ Potential issue | 🟡 Minor

Guard standard deviation computation against tiny negative variance.

If numerical noise returns a slightly negative objective, Line 34 can produce invalid output formatting. Clamp before sqrt.

💡 Proposed fix

 if problem.Status.name in ["Optimal", "PrimalFeasible"]:
     print(f"Portfolio variance: {problem.ObjValue:.6f}")
-    print(f"Std dev: {problem.ObjValue**0.5:.4f}")
+    variance = max(problem.ObjValue, 0.0)
+    print(f"Std dev: {variance**0.5:.4f}")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-qp-api-python/assets/portfolio/model.py around lines 33
- 35, The Std dev print uses problem.ObjValue directly which can be slightly
negative due to numerical noise; before taking the square root in the Std dev
calculation (around where problem.ObjValue is used for printing and alongside
x1.getValue()), clamp the variance with something like var =
max(problem.ObjValue, 0.0) and then compute sqrt(var) for the Std dev print,
ensuring the formatted output uses the clamped value while leaving the original
problem.ObjValue unmodified where you still want to display the raw variance.

.github/skills/cuopt-lp-milp-api-python/assets/milp_basic/incumbent_callback.py-40-40 (1)

40-40: ⚠️ Potential issue | 🟡 Minor

Guard objective printing by solver status.

On line 40, problem.ObjValue is printed unconditionally. The incumbent callback can terminate with various statuses (Optimal, FeasibleFound, TimeLimit, NumericalIssues, etc.), and accessing ObjValue without checking status first may be unsafe or misleading. This pattern is inconsistent with standard cuOpt examples.

Proposed change

-    print(f"Status: {problem.Status.name}, Objective: {problem.ObjValue}")
+    if problem.Status.name in ["Optimal", "FeasibleFound"]:
+        print(f"Status: {problem.Status.name}, Objective: {problem.ObjValue}")
+    else:
+        print(f"Status: {problem.Status.name}")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
@.github/skills/cuopt-lp-milp-api-python/assets/milp_basic/incumbent_callback.py
at line 40, The print unconditionally reads problem.ObjValue even when the
solver status may not have a valid incumbent; update the incumbent callback (the
function/class that contains the print of "Status: {problem.Status.name},
Objective: {problem.ObjValue}") to first check problem.Status for a
feasible/optimal state (e.g., Optimal or FeasibleFound/Feasible) before
accessing problem.ObjValue, and if not feasible just print the status (or a
placeholder) without reading ObjValue; replace the single unconditional print
with a guarded conditional that only reads ObjValue when the status indicates a
valid incumbent.

.github/skills/cuopt-lp-milp-formulation/SKILL.md-49-57 (1)

49-57: ⚠️ Potential issue | 🟡 Minor

Heading/text mismatch: “Three labels” but four labels are defined.

Please rename the section title (e.g., “Four labels”) to match the table content.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-formulation/SKILL.md around lines 49 - 57, The
section heading "Three labels" in SKILL.md is inconsistent with the table that
defines four labels; update the heading text from "Three labels" to "Four
labels" (or another accurate heading) so the title matches the table content,
making sure to update the exact heading string "Three labels" in the markdown
file.

.github/skills/cuopt-lp-milp-api-python/SKILL.md-205-217 (1)

205-217: ⚠️ Potential issue | 🟡 Minor

Add blank lines around markdown tables to satisfy lint.

MD058 is triggered around the "Minimal / canonical examples" and "Other reference" tables.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/SKILL.md around lines 205 - 217, The
markdown tables under the headings "Minimal / canonical examples (LP & MILP)"
and "Other reference" are missing blank lines before and after them (triggering
MD058); edit SKILL.md to insert a blank line between each heading/paragraph and
its following table and also a blank line after each table so the tables are
separated from subsequent content (ensure the tables for lp_basic, lp_duals,
lp_warmstart, milp_basic, milp_production_planning and mps_solver are each
surrounded by an empty line to satisfy the MD058 lint rule).

.github/skills/cuopt-lp-milp-api-python/SKILL.md-33-33 (1)

33-33: ⚠️ Potential issue | 🟡 Minor

Fix malformed table row (column count mismatch).

The Unclear row has 2 cells while the table defines 3 columns (MD056).

Suggested fix

-| **Unclear** | Prefer **INTEGER** if the noun is a countable thing (a worker, a car); prefer **CONTINUOUS** if it's a measure (amount of steel, hours worked). If the problem says "whole" or "integer" or "number of", use INTEGER. |
+| **Unclear** | Prefer **INTEGER** if the noun is a countable thing (a worker, a car); prefer **CONTINUOUS** if it's a measure (amount of steel, hours worked). If the problem says "whole" or "integer" or "number of", use INTEGER. | Ask a clarifying question if domain wording remains ambiguous. |

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/SKILL.md at line 33, The markdown
table row for "Unclear" has only 2 cells while the table defines 3 columns;
update the row in SKILL.md by adding the missing third cell (either a brief
explanatory note or an empty cell placeholder) so the "Unclear" row matches the
header's three-column structure and resolves the MD056 column count mismatch.

.github/skills/cuopt-routing-api-python/SKILL.md-44-46 (1)

44-46: ⚠️ Potential issue | 🟡 Minor

np.array is used without importing NumPy in the snippet.

This code block is non-runnable as-is when copied. Add the import to make the example complete and functional.

Suggested fix

 ```python
+import numpy as np
 # Pickup-delivery pairs
 dm.set_pickup_delivery_pairs(pickup_indices, delivery_indices)
 
 # Precedence
 dm.add_order_precedence(node_id=2, preceding_nodes=np.array([0, 1]))

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-routing-api-python/SKILL.md around lines 44 - 46, The
snippet uses np.array in the example for dm.add_order_precedence but NumPy is
not imported; add an import line (import numpy as np) at the top of the code
example so np.array is defined and the example using
dm.add_order_precedence(node_id=2, preceding_nodes=np.array([0, 1])) is
runnable.

.github/skills/cuopt-lp-milp-api-python/SKILL.md-73-93 (1)

73-93: ⚠️ Potential issue | 🟡 Minor

MILP snippet is missing SolverSettings import.

This code block will fail with NameError: name 'SolverSettings' is not defined if copied independently.

Suggested fix

 from cuopt.linear_programming.problem import Problem, CONTINUOUS, INTEGER, MINIMIZE
+from cuopt.linear_programming.solver_settings import SolverSettings

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/SKILL.md around lines 73 - 93, The
snippet uses SolverSettings but never imports it, causing a NameError; add an
import for SolverSettings (e.g., add "from cuopt.linear_programming.solver
import SolverSettings") at the top of the example so the symbol SolverSettings
referenced when creating settings is defined and the MILP settings block
(settings.set_parameter(...)) works.

.github/skills/cuopt-routing-api-python/SKILL.md-84-84 (1)

84-84: ⚠️ Potential issue | 🟡 Minor

Asymmetric cost matrices are valid; remove strict symmetry check.

The original guidance incorrectly implies that cost matrices must be symmetric. Per official NVIDIA documentation, asymmetric matrices are explicitly supported in cuOpt. Real-world routing scenarios frequently require asymmetric costs (one-way routes, directional preferences, time-dependent travel costs).

Suggested fix

-| Wrong cost | Check cost_matrix is symmetric |
+| Wrong cost | Check matrix indexing, units, and directionality assumptions (asymmetric costs may be valid) |

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-routing-api-python/SKILL.md at line 84, Update the
guidance that enforces or suggests cost matrices must be symmetric: remove the
"Check cost_matrix is symmetric" assertion and replace it with a note that
asymmetric cost matrices are supported by cuOpt (directional/one-way costs are
valid), referencing the table entry "Wrong cost" and the existing "Check
cost_matrix is symmetric" text so you change that cell to something like "Verify
cost_matrix values and indexing; asymmetric matrices are supported; ensure costs
correspond to directed routes." Ensure the revised wording clarifies asymmetry
is allowed and suggests validating matrix indexing and units rather than
enforcing symmetry.

.github/skills/cuopt-lp-milp-api-python/assets/lp_duals/model.py-25-25 (1)

25-25: ⚠️ Potential issue | 🟡 Minor

Use enum comparison instead of fragile string matching against enum names.

Line 25 compares problem.Status.name against hardcoded strings, which breaks if enum member names drift. Prefer direct enum comparison:

Recommended fix

+from cuopt.linear_programming.solver.solver_wrapper import LPTerminationStatus
+
 def main():
     problem = Problem("min_dual_rc")
     ...
     problem.solve()

-    if problem.Status.name in ["Optimal", "PrimalFeasible"]:
+    if problem.Status in (LPTerminationStatus.Optimal, LPTerminationStatus.PrimalFeasible):

This eliminates fragility by comparing enum values directly rather than relying on string name stability.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/lp_duals/model.py at line 25,
Replace the fragile string check "if problem.Status.name in ['Optimal',
'PrimalFeasible']" with direct enum comparisons against the solver's status
constants (e.g., use gp.GRB.OPTIMAL and gp.GRB.PRIMAL_FEASIBLE or the
appropriate Status enum in scope). For example, change the condition to check
problem.Status == gp.GRB.OPTIMAL or problem.Status in {gp.GRB.OPTIMAL,
gp.GRB.PRIMAL_FEASIBLE} so that the code compares enum values directly
(referencing problem.Status and the GRB status constants).

.github/skills/cuopt-installation-api-python/resources/verification_examples.md-94-95 (1)

94-95: ⚠️ Potential issue | 🟡 Minor

Avoid false negatives when CONDA_PREFIX is unset.

This compile check drops the fallback used above; on non-conda setups it points to /include and can report a misleading failure.

Suggested patch

-gcc -I${CONDA_PREFIX}/include -c /tmp/test_cuopt.c -o /tmp/test_cuopt.o && \
+gcc -I${CONDA_PREFIX:-/usr}/include -c /tmp/test_cuopt.c -o /tmp/test_cuopt.o && \
   echo "C API headers OK" || echo "C API headers not found"

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
@.github/skills/cuopt-installation-api-python/resources/verification_examples.md
around lines 94 - 95, The gcc compile check uses -I${CONDA_PREFIX}/include
unguarded which expands to /include when CONDA_PREFIX is empty and causes false
negatives; change the one-line check so the -I flag is only added when
CONDA_PREFIX is set (e.g. use the parameter expansion form
${CONDA_PREFIX:+-I${CONDA_PREFIX}/include} or wrap the gcc invocation in a
conditional that tests CONDA_PREFIX), update the echoed messages accordingly,
and keep the same gcc ... /tmp/test_cuopt.c -o /tmp/test_cuopt.o && echo ... ||
echo ... structure.

.github/skills/cuopt-lp-milp-api-c/assets/lp_duals/lp_duals.c-64-88 (1)

64-88: ⚠️ Potential issue | 🟡 Minor

Status variable reuse may cause incorrect exit code.

The status variable is overwritten by cuOptGetDualSolution (line 66) and cuOptGetReducedCosts (line 76). The final return statement (line 88) checks status, which would reflect the last API call's status rather than the solve status. If the solve succeeds but cuOptGetReducedCosts fails, the program returns 1 even though the main computation succeeded.

Proposed fix: use separate variables for retrieval status

     cuopt_float_t *dual = malloc((size_t)num_constraints * sizeof(cuopt_float_t));
     if (dual) {
-        status = cuOptGetDualSolution(solution, dual);
-        if (status == CUOPT_SUCCESS) {
+        cuopt_int_t dual_status = cuOptGetDualSolution(solution, dual);
+        if (dual_status == CUOPT_SUCCESS) {
             printf("Constraint c1 DualValue = %f\n", dual[0]);
             printf("Constraint c2 DualValue = %f\n", dual[1]);
         }
         free(dual);
     }

     cuopt_float_t *reduced = malloc((size_t)num_variables * sizeof(cuopt_float_t));
     if (reduced) {
-        status = cuOptGetReducedCosts(solution, reduced);
-        if (status == CUOPT_SUCCESS) {
+        cuopt_int_t reduced_status = cuOptGetReducedCosts(solution, reduced);
+        if (reduced_status == CUOPT_SUCCESS) {
             printf("x ReducedCost = %f, y ReducedCost = %f, z ReducedCost = %f\n",
                    reduced[0], reduced[1], reduced[2]);
         }
         free(reduced);
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-c/assets/lp_duals/lp_duals.c around lines
64 - 88, The code reuses the `status` variable for API calls
`cuOptGetDualSolution` and `cuOptGetReducedCosts`, which can overwrite the
original solve result; change to separate result variables (e.g.,
`solve_status`, `dual_status`, `reduced_status`) so `solve_status` holds the
solver outcome and only the retrieval calls assign to their own variables before
logging; ensure the final return checks `solve_status == CUOPT_SUCCESS` and not
the last retrieval status, and update references to `status` around
`cuOptGetDualSolution`, `cuOptGetReducedCosts`, and the final `return`
accordingly while still freeing `dual`/`reduced` and performing cleanup.

.github/skills/cuopt-lp-milp-api-python/assets/lp_warmstart/model.py-34-35 (1)

34-35: ⚠️ Potential issue | 🟡 Minor

Add status check before accessing objective value.

The first problem's solve result is accessed without checking the status, unlike the second problem (line 47). If the solve fails, problem.ObjValue may raise an exception or return invalid data.

Proposed fix

     problem.solve(settings)
-    print(f"Objective: {problem.ObjValue}")
+    if problem.Status.name in ["Optimal", "PrimalFeasible"]:
+        print(f"Objective: {problem.ObjValue}")
+    else:
+        print(f"Problem 1 Status: {problem.Status.name}")
+        return

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/lp_warmstart/model.py around
lines 34 - 35, The code prints problem.ObjValue immediately after calling
problem.solve(settings); update it to first check the solver status (match the
pattern used for the second problem around line 47) by inspecting the problem's
status property or SolveStatus after problem.solve(settings), handle
non-optimal/failure cases (log or raise) and only access/print problem.ObjValue
when the status indicates a valid optimal/feasible solution; ensure you modify
the block that calls problem.solve and the subsequent print so it mirrors the
guarded check used for the second problem.

.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/data/README.md-62-64 (1)

62-64: ⚠️ Potential issue | 🟡 Minor

Clarify execution directory for Line 63 command.

model.py is not in this data/ directory, so python model.py ... is ambiguous/broken when run from here.

Suggested docs fix

-```bash
-python model.py --file path/to/your/problem.mps
-```
+From `assets/mps_solver/`:
+```bash
+python model.py --file data/your_problem.mps
+```
+
+From `assets/mps_solver/data/`:
+```bash
+python ../model.py --file path/to/your/problem.mps
+```

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/data/README.md
around lines 62 - 64, The README shows an ambiguous command "python model.py
--file ..." that fails when run from the data/ directory; update the README
(lines around the code block) to clarify execution contexts by adding two
explicit examples: one showing how to run model.py from the assets/mps_solver/
directory using data/your_problem.mps as the file, and another showing how to
run it from inside assets/mps_solver/data/ by invoking ../model.py with the
correct relative path to the .mps file; reference the existing model.py script
and the assets/mps_solver/data/ directory in the updated text so users know
which working directory to use.

.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py-150-155 (1)

150-155: ⚠️ Potential issue | 🟡 Minor

Prefix unused variable with underscore.

The problem variable from unpacking is never used.

Proposed fix

-        problem, solution = solve_mps(
+        _, solution = solve_mps(

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py around
lines 150 - 155, The unpacked variable problem returned by solve_mps is unused;
update the unpacking at the call site (the solve_mps invocation) to prefix the
unused variable with an underscore (e.g., _problem, solution = solve_mps(...))
or use a single underscore to ignore it, so that the linter/compiler no longer
flags an unused variable.

.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py-34-34 (1)

34-34: ⚠️ Potential issue | 🟡 Minor

Remove extraneous f prefix from string literal.

This f-string has no placeholders, so the f prefix is unnecessary.

Proposed fix

-    print(f"Downloading air05.mps from MIPLIB...")
+    print("Downloading air05.mps from MIPLIB...")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py at line
34, The print statement uses an unnecessary f-string; locate the print call that
contains the literal "Downloading air05.mps from MIPLIB..." and remove the
leading f so it becomes a normal string literal (replace print(f"Downloading
air05.mps from MIPLIB...") with print("Downloading air05.mps from MIPLIB...")).

.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/results.md (1)

27-30: Clarify the two different gap metrics to avoid misinterpretation.

Gap to Optimal in the table (vs best-known objective) and solver relative_mip_gap in logs are not the same metric. Please add a brief note so readers don’t compare them directly.

Also applies to: 74-77

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/results.md around
lines 27 - 30, Add a short clarifying note beneath the results table explaining
that the table column "Gap to Optimal" is computed as the percentage gap between
the reported Objective and a best-known (external) optimal value, while the
solver's "relative_mip_gap" (mentioned in logs) is the solver's internal
stopping tolerance; explicitly state they use different baselines and should not
be compared directly (also add the same note near the other instance at lines
74-77). Reference the table header "Gap to Optimal" and the solver metric name
"relative_mip_gap" so readers know exactly which values are being contrasted.

.github/skills/cuopt-user-rules/SKILL.md (1)

16-19: Polish repeated question stems for readability.

These bullets currently start with “What” repeatedly. Consider varying phrasing (e.g., “Which language/interface...”, “Required output format...”) to improve flow.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-user-rules/SKILL.md around lines 16 - 19, Edit the
bullet list in SKILL.md to remove repetitive "What" at the start of each item
for better readability: replace "What **language/interface**?" with e.g. "Which
language/interface is required?", change "What problem type?" to "Problem
type:", change "What constraints matter?" to "Relevant constraints:", and change
"What output format?" to "Required output format:" (or similar varied phrasing)
so each list item reads distinctly while preserving the original meaning.

.github/skills/cuopt-qp-api-c/SKILL.md (1)

3-10: Clarify “C only” vs “C/C++” wording to avoid routing ambiguity.

Line 3 implies dual-language scope, while Line 10 narrows to C only. Suggest explicitly saying this is the C API skill and it can be called from C/C++ codebases.

Suggested wording diff

-description: Quadratic Programming (QP) with cuOpt — C API. Use when the user is embedding QP in C/C++.
+description: Quadratic Programming (QP) with cuOpt — C API. Use when the user needs the cuOpt C API (from C or C++ codebases).
@@
-This skill is **C only**.
+This skill covers the **cuOpt C API**.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-qp-api-c/SKILL.md around lines 3 - 10, Clarify the
language to avoid routing ambiguity: update the SKILL.md header and the sentence
"This skill is **C only**" to explicitly state this is the "C API skill" and
that the C API can be invoked from both C and C++ codebases (e.g., change
wording around "cuOpt QP — C API" and the line asserting "This skill is **C
only**" to something like "This skill exposes the cuOpt QP C API; it is intended
for C projects and can also be called from C++ codebases"), ensuring the
document still warns that the API surface is C-based and QP must be
minimization.

.github/skills/cuopt-qp-formulation/SKILL.md (1)

12-13: Add one sentence clarifying coefficient interpretation in xᵀQx.

A brief note on how coefficients map to terms (especially diagonals vs cross terms) would reduce formulation mistakes.

Based on learnings: In cuOPT's quadratic programming API, the user-facing convention is x^T Q x, with diagonal q_i mapping to q_i * x_i^2.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-qp-formulation/SKILL.md around lines 12 - 13, Add one
clarifying sentence to the quadratic objective description stating that the API
follows the xᵀQx convention where diagonal elements Q_ii (or q_i) correspond to
coefficients of x_i^2 (i.e., Q_ii * x_i^2) and off-diagonal elements Q_ij
contribute to cross terms (e.g., Q_ij * x_i * x_j), so authors should supply Q
with those mappings in mind when forming the objective xᵀQx.

.github/skills/cuopt-server-api-python/SKILL.md (1)

46-48: Add error handling for HTTP status and safe JSON parsing in the example.

Lines 46–48 assume success and directly read reqId without checking the HTTP status code. If the server returns a 4xx or 5xx error, r.json()["reqId"] will produce a misleading JSON parsing error instead of surfacing the HTTP failure. Additionally, a timeout should be specified to prevent indefinite hangs.

Suggested doc snippet update

-r = requests.post(f"{SERVER}/cuopt/request", json=payload, headers=HEADERS)
-req_id = r.json()["reqId"]
+r = requests.post(f"{SERVER}/cuopt/request", json=payload, headers=HEADERS, timeout=30)
+r.raise_for_status()
+body = r.json()
+req_id = body.get("reqId")
+if not req_id:
+    raise ValueError(f"Missing reqId in response: {body}")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-server-api-python/SKILL.md around lines 46 - 48, The
example POST call assigns the response to r and immediately indexes
r.json()["reqId"] without checking HTTP status or handling JSON errors and lacks
a timeout; update the call that posts to f"{SERVER}/cuopt/request" (using
variables SERVER, payload, HEADERS) to include a timeout parameter, verify
success via r.raise_for_status() or by inspecting r.status_code, then parse JSON
in a try/except to surface HTTP errors or JSONDecodeError and only then extract
req_id (req_id = ...), returning or logging clear error messages on failure.

.github/skills/cuopt-lp-milp-api-python/assets/milp_basic/incumbent_callback.py (1)

36-36: Keep a strong reference to the callback object.

On line 36, passing IncumbentCallback() inline may lead to garbage collection before or during problem.solve(). The official cuOpt documentation explicitly advises against this pattern. Keep the callback instance alive for the duration of the solve by assigning it to a named variable.

Proposed change

-    settings.set_mip_callback(IncumbentCallback())
+    incumbent_callback = IncumbentCallback()
+    settings.set_mip_callback(incumbent_callback)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
@.github/skills/cuopt-lp-milp-api-python/assets/milp_basic/incumbent_callback.py
at line 36, The callback instance passed inline to settings.set_mip_callback may
be garbage-collected during problem.solve() — create and retain a strong
reference by instantiating IncumbentCallback() into a variable (e.g., callback =
IncumbentCallback()) and then pass that variable to
settings.set_mip_callback(callback); ensure the variable outlives the solve call
so the callback object remains alive for the duration of the solve.

.github/skills/cuopt-lp-milp-api-python/assets/milp_production_planning/model.py (1)

16-18: Material is redundant with Machine_Time.

Line 18 is a scaled duplicate of Line 16, so it does not constrain the model further. Consider making material coefficients/RHS independent to keep the example formulation meaningful.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
@.github/skills/cuopt-lp-milp-api-python/assets/milp_production_planning/model.py
around lines 16 - 18, The Material constraint is a scaled duplicate of
Machine_Time and thus redundant; update the coefficients or RHS for the
constraint added via problem.addConstraint with name "Material" (currently the 4
* x1 + 2 * x2 <= 200 line) so it becomes independent (e.g., change coefficients
or RHS to reflect distinct material limits) ensuring the "Material" constraint
meaningfully differs from the "Machine_Time" constraint.

.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py (1)

116-118: Silent exception handling obscures errors.

Catching a broad Exception and passing silently makes debugging difficult. Consider logging or at least narrowing the exception type.

Proposed improvement

-        except (AttributeError, Exception):
-            # For MPS problems, variable access may be limited
-            pass
+        except AttributeError:
+            # For MPS problems, variable access may be limited
+            if verbose:
+                print("Note: Variable values not accessible for this problem type")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py around
lines 116 - 118, The current except block "except (AttributeError, Exception):
pass" swallows all errors; change it to catch only the specific expected error
(e.g., "except AttributeError:") and add logging of the exception (use
logging.exception or logger.exception with a clear message about variable access
in MPS parsing) so unexpected errors are visible; if there are other known,
narrower exceptions to handle, list them explicitly rather than using Exception,
and re-raise any unknown exceptions after logging.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py (2)

83-85: ⚠️ Potential issue | 🔴 Critical

Call cuOpt Problem accessors; current code likely stores bound methods instead of values.

At Line 83-85 and Line 105-107, problem.NumVariables, problem.NumConstraints, and problem.IsMIP should be invoked if they are methods; otherwise logs/JSON will contain method objects.

Proposed fix

-    print(f"Variables: {problem.NumVariables}")
-    print(f"Constraints: {problem.NumConstraints}")
-    print(f"Is MIP: {problem.IsMIP}")
+    print(f"Variables: {problem.NumVariables()}")
+    print(f"Constraints: {problem.NumConstraints()}")
+    print(f"Is MIP: {problem.IsMIP()}")
@@
-            "num_variables": problem.NumVariables,
-            "num_constraints": problem.NumConstraints,
-            "is_mip": problem.IsMIP,
+            "num_variables": problem.NumVariables(),
+            "num_constraints": problem.NumConstraints(),
+            "is_mip": problem.IsMIP(),

#!/bin/bash
set -euo pipefail
# Verify whether these are methods or properties in the repository version.
fd 'problem.py|problem.pyi' | xargs -r rg -n -C3 'class Problem|def NumVariables|def NumConstraints|def IsMIP|@property'

Also applies to: 105-107

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py around
lines 83 - 85, The prints/logs are capturing bound method objects instead of
their return values; call/invoke the cuOpt Problem accessors rather than
referencing them. Replace uses of problem.NumVariables, problem.NumConstraints,
and problem.IsMIP (also the occurrences around the later prints at the other
block) with problem.NumVariables(), problem.NumConstraints(), and
problem.IsMIP() if those are methods (or leave as properties only if inspection
of Problem shows `@property`), and update any JSON/log serialization to use the
returned values from NumVariables(), NumConstraints(), and IsMIP() rather than
the method objects.

---

129-129: ⚠️ Potential issue | 🟠 Major

gap_to_optimal is incorrectly tied to AIR05 even for non-AIR05 input files.

Line 157-164 (and related CLI output at Line 206-207, 214-215, 249-252) produces misleading metrics when --file is not air05.mps.

Proposed fix (parameterize known optimum)

-def compare_gaps(filepath: str, time_limit: float = 120.0) -> dict:
+def compare_gaps(
+    filepath: str,
+    time_limit: float = 120.0,
+    known_optimal: float | None = None,
+) -> dict:
@@
-        if solution:
-            results[gap] = {
+        if solution:
+            result = {
                 "objective": solution["objective"],
                 "status": solution["status"],
-                "gap_to_optimal": (solution["objective"] - AIR05_OPTIMAL)
-                / AIR05_OPTIMAL
-                * 100,
             }
+            if known_optimal:
+                result["gap_to_optimal"] = (
+                    (solution["objective"] - known_optimal) / known_optimal * 100
+                )
+            results[gap] = result

Also applies to: 157-164, 206-207, 214-215, 249-252

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py at line
129, The compare_gaps function currently computes gap_to_optimal using a
hardcoded AIR05 optimum regardless of the input file, causing misleading
metrics; update compare_gaps to determine the correct known_optimum per filepath
(e.g., map filenames or accept a known_optimum parameter) and use that value
when computing gap_to_optimal and related CLI output; locate references to
gap_to_optimal, known_optimum and the compare_gaps signature and either add a
function parameter (known_optimum: Optional[float]) or a filename→optimum
lookup, ensure CLI code that calls compare_gaps passes the correct optimum when
provided, and update the printed metrics to use the resolved optimum.

.github/skills/cuopt-lp-milp-api-c/assets/mps_solver/mps_solver.c (1)

41-43: ⚠️ Potential issue | 🟠 Major

Check every cuOpt API return code before consuming outputs.

At Line 41-43, Line 53-55, and Line 63, cuOpt calls are currently unchecked. If any fails, subsequent values (objective_value, time, termination_status, primal) may be invalid while the program can still exit as success.

Proposed fix

-    cuOptCreateSolverSettings(&settings);
-    cuOptSetFloatParameter(settings, CUOPT_TIME_LIMIT, 60.0);
-    cuOptSetFloatParameter(settings, CUOPT_MIP_RELATIVE_GAP, 0.01);
+    status = cuOptCreateSolverSettings(&settings);
+    if (status != CUOPT_SUCCESS) {
+        printf("Error creating solver settings: %d\n", status);
+        goto cleanup;
+    }
+    status = cuOptSetFloatParameter(settings, CUOPT_TIME_LIMIT, 60.0);
+    if (status != CUOPT_SUCCESS) {
+        printf("Error setting CUOPT_TIME_LIMIT: %d\n", status);
+        goto cleanup;
+    }
+    status = cuOptSetFloatParameter(settings, CUOPT_MIP_RELATIVE_GAP, 0.01);
+    if (status != CUOPT_SUCCESS) {
+        printf("Error setting CUOPT_MIP_RELATIVE_GAP: %d\n", status);
+        goto cleanup;
+    }
@@
-    cuOptGetObjectiveValue(solution, &objective_value);
-    cuOptGetSolveTime(solution, &time);
-    cuOptGetTerminationStatus(solution, &termination_status);
+    status = cuOptGetObjectiveValue(solution, &objective_value);
+    if (status != CUOPT_SUCCESS) {
+        printf("Error getting objective value: %d\n", status);
+        goto cleanup;
+    }
+    status = cuOptGetSolveTime(solution, &time);
+    if (status != CUOPT_SUCCESS) {
+        printf("Error getting solve time: %d\n", status);
+        goto cleanup;
+    }
+    status = cuOptGetTerminationStatus(solution, &termination_status);
+    if (status != CUOPT_SUCCESS) {
+        printf("Error getting termination status: %d\n", status);
+        goto cleanup;
+    }
@@
-        cuOptGetPrimalSolution(solution, primal);
+        status = cuOptGetPrimalSolution(solution, primal);
+        if (status != CUOPT_SUCCESS) {
+            printf("Error getting primal solution: %d\n", status);
+            goto cleanup;
+        }
@@
-        free(primal);
+        free(primal);
+        primal = NULL;
@@
 cleanup:
+    free(primal);
     cuOptDestroyProblem(&problem);
     cuOptDestroySolverSettings(&settings);
     cuOptDestroySolution(&solution);

Also applies to: 53-55, 63-63

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-c/assets/mps_solver/mps_solver.c around
lines 41 - 43, All cuOpt API calls must have their return codes checked before
using outputs: wrap calls like cuOptCreateSolverSettings,
cuOptSetFloatParameter, cuOptSolveModel, and
cuOptGetSolutionObjectiveValue/cuOptGetSolutionPrimal/cuOptGetSolveInfo with
error checks and bail out (log error and return/fail) if the returned status is
not success; do this for the calls at the sites where settings are
created/parameters set (cuOptCreateSolverSettings, cuOptSetFloatParameter), when
solving (cuOptSolveModel), and when retrieving outputs
(cuOptGetSolutionObjectiveValue, cuOptGetSolutionPrimal, cuOptGetSolveInfo), so
that invalid outputs are never used after a failed API call.

.github/skills/cuopt-routing-api-python/assets/vrp_basic/model.py (1)

23-23: ⚠️ Potential issue | 🟠 Major

Previously flagged issue remains at Line 23: order_locations should be int32.

cudf.Series([1, 2, 3]) can default to int64; cast explicitly before passing to set_order_locations.

Required fix

-dm.set_order_locations(cudf.Series([1, 2, 3]))
+dm.set_order_locations(cudf.Series([1, 2, 3], dtype="int32"))

#!/bin/bash
set -euo pipefail

# Confirm API dtype requirement and unresolved call in this file.
rg -n -C2 'order_locations : cudf.Series dtype - int32|def set_order_locations' python/cuopt/cuopt/routing/vehicle_routing.py
rg -n -C2 'set_order_locations\(' .github/skills/cuopt-routing-api-python/assets/vrp_basic/model.py

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-routing-api-python/assets/vrp_basic/model.py at line
23, The call dm.set_order_locations(cudf.Series([1, 2, 3])) uses a default
integer dtype (likely int64); change it to explicitly cast the series to int32
before passing to set_order_locations so order_locations meets the API dtype
requirement—e.g., construct or cast the cudf.Series to dtype="int32" so the
argument passed to set_order_locations is int32.

.github/skills/cuopt-lp-milp-api-c/assets/milp_basic/milp_simple.c (1)

48-51: ⚠️ Potential issue | 🟠 Major

Unresolved: solver-settings return values are still unchecked.

At Lines 48-51, failures from cuOptCreateSolverSettings / cuOptSetFloatParameter can be silently ignored.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-c/assets/milp_basic/milp_simple.c around
lines 48 - 51, The calls to cuOptCreateSolverSettings and cuOptSetFloatParameter
(for CUOPT_MIP_ABSOLUTE_TOLERANCE, CUOPT_MIP_RELATIVE_GAP, CUOPT_TIME_LIMIT)
ignore return values and can fail silently; update the code to check each
function's return status (the result of cuOptCreateSolverSettings and each
cuOptSetFloatParameter call), and on error log the status and perform
appropriate cleanup/exit (e.g., free settings if created and return non-zero or
exit) so failures are not ignored—use the same settings variable and the three
parameter calls to locate where to add the checks and error handling.

.github/skills/cuopt-user-rules/SKILL.md (1)

16-19: Tighten repeated bullet phrasing for readability

Line 16-19 repeats “What …?” in consecutive bullets. Minor rewording would read cleaner.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-user-rules/SKILL.md around lines 16 - 19, The
consecutive bullets repeating “What …?” are repetitive; edit the SKILL.md
bullets to use parallel, concise phrasing instead (e.g., "Language/interface",
"Problem type", "Relevant constraints", "Desired output format") so they read
cleaner and avoid repeating the word "What" while preserving the original intent
and order of the four questions.

.github/skills/cuopt-lp-milp-api-cli/SKILL.md (1)

49-49: Clarify LP vs MILP behavior when integer markers are absent.

At Line 49, add one explicit sentence: if INTORG/INTEND markers are not present, the model is treated as LP (not MILP). This avoids formulation ambiguity.

Based on learnings, in MIP problems at least one integer variable must exist; otherwise the model is LP by definition.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-cli/SKILL.md at line 49, Add a single
clarifying sentence after the line containing "Integer variables: use 'MARKER'
'INTORG' before and 'MARKER' 'INTEND' after the integer columns" stating that if
the 'INTORG'/'INTEND' markers are not present the model will be treated as an LP
(not an MILP), and remind that a MIP requires at least one integer variable to
be considered MILP; reference the 'INTORG' and 'INTEND' markers and the MARKER
usage in that sentence.

.github/skills/cuopt-qp-api-python/assets/maximization_workaround/model.py (1)

10-22: Wrap module-level code in main() with if __name__ == "__main__": guard.

Lines 10-22 execute problem.solve() at module import time. While this module is not imported elsewhere in the codebase, wrapping the code in a main() function with the standard guard is a best practice for documentation examples and makes the intent explicit (this code is meant to run standalone, not be imported).

♻️ Proposed refactor

-problem = Problem("MaxWorkaround")
-
-x = problem.addVariable(lb=0, ub=10, vtype=CONTINUOUS, name="x")
-problem.setObjective(x * x - 4 * x, sense=MINIMIZE)
-
-problem.solve()
-
-if problem.Status.name in ["Optimal", "PrimalFeasible"]:
-    print(f"x = {x.getValue():.4f}")
-    print(f"Minimized value = {problem.ObjValue:.4f}")
-    print(f"Original maximum = {-problem.ObjValue:.4f}")
-else:
-    print(f"Status: {problem.Status.name}")
+def main():
+    problem = Problem("MaxWorkaround")
+    x = problem.addVariable(lb=0, ub=10, vtype=CONTINUOUS, name="x")
+    problem.setObjective(x * x - 4 * x, sense=MINIMIZE)
+
+    problem.solve()
+
+    if problem.Status.name in ["Optimal", "PrimalFeasible"]:
+        print(f"x = {x.getValue():.4f}")
+        print(f"Minimized value = {problem.ObjValue:.4f}")
+        print(f"Original maximum = {-problem.ObjValue:.4f}")
+    else:
+        print(f"Status: {problem.Status.name}")
+
+
+if __name__ == "__main__":
+    main()

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-qp-api-python/assets/maximization_workaround/model.py
around lines 10 - 22, The module currently runs solver code at import time
(creating Problem, calling problem.addVariable, problem.setObjective and
problem.solve and printing results); refactor by moving that sequence into a new
main() function (e.g., def main(): create Problem("MaxWorkaround"), addVariable,
setObjective, call problem.solve and print results) and add the standard guard
if __name__ == "__main__": main() so importing the module no longer executes
problem.solve() automatically.

.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py (1)

42-44: Stream decompression instead of reading the full gzip file into memory.

Line 42-44 uses f_in.read() which buffers the full file; use streamed copy to reduce memory pressure.

Proposed refactor

+import shutil
@@
-    with gzip.open(gz_file, "rb") as f_in:
-        with open(mps_file, "wb") as f_out:
-            f_out.write(f_in.read())
+    with gzip.open(gz_file, "rb") as f_in:
+        with open(mps_file, "wb") as f_out:
+            shutil.copyfileobj(f_in, f_out)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py around
lines 42 - 44, The current decompression reads the entire gzip into memory via
f_in.read(); replace that with a streamed copy to avoid buffering the whole
file—inside the with gzip.open(gz_file, "rb") as f_in: with open(mps_file, "wb")
as f_out: block, use a streamed transfer (e.g., shutil.copyfileobj(f_in, f_out)
or a small-chunk read/write loop) so gz_file is decompressed to mps_file
incrementally rather than all at once.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

.github/skills/cuopt-lp-milp-api-c/assets/milp_production_planning/milp_production.c (1)

76-86: ⚠️ Potential issue | 🟡 Minor

Handle solution-buffer allocation failure explicitly.

On Line 76, if malloc returns NULL, the code currently skips primal extraction and can still exit successfully. Please set a non-success status and go to cleanup in that branch.

Suggested fix

     cuopt_float_t *sol = malloc((size_t)num_variables * sizeof(cuopt_float_t));
     if (sol) {
         status = cuOptGetPrimalSolution(solution, sol);
         if (status != CUOPT_SUCCESS) {
             printf("Error getting primal solution: %d\n", status);
             free(sol);
             goto cleanup;
         }
         printf("Product_A: %f, Product_B: %f\n", sol[0], sol[1]);
         free(sol);
+    } else {
+        fprintf(stderr, "Error: failed to allocate primal solution buffer\n");
+        status = -1;
+        goto cleanup;
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
@.github/skills/cuopt-lp-milp-api-c/assets/milp_production_planning/milp_production.c
around lines 76 - 86, If malloc for sol returns NULL, the code currently
continues as if successful; update the malloc failure branch in the block that
allocates cuopt_float_t *sol so it sets a non-success status (e.g. status =
CUOPT_ERROR or another appropriate non-success constant) and jumps to the
existing cleanup label (goto cleanup) instead of silently skipping extraction;
adjust the branch around sol, cuOptGetPrimalSolution, and cleanup to ensure
allocation failures are handled consistently.

.github/skills/cuopt-lp-milp-api-c/assets/lp_duals/lp_duals.c (1)

85-109: ⚠️ Potential issue | 🟠 Major

Status variable overwrite masks potential failures.

Lines 87 and 97 overwrite status with post-solve query results. If cuOptGetDualSolution fails but cuOptGetReducedCosts succeeds, the return value incorrectly indicates success while masking the dual retrieval failure. Use separate status variables for these optional queries to preserve the solve result.

Suggested fix

     cuopt_float_t *dual = malloc((size_t)num_constraints * sizeof(cuopt_float_t));
     if (dual) {
-        status = cuOptGetDualSolution(solution, dual);
-        if (status == CUOPT_SUCCESS) {
+        cuopt_int_t dual_status = cuOptGetDualSolution(solution, dual);
+        if (dual_status == CUOPT_SUCCESS) {
             printf("Constraint c1 DualValue = %f\n", dual[0]);
             printf("Constraint c2 DualValue = %f\n", dual[1]);
+        } else {
+            printf("Warning: could not retrieve dual solution: %d\n", dual_status);
         }
         free(dual);
     }
 
     cuopt_float_t *reduced = malloc((size_t)num_variables * sizeof(cuopt_float_t));
     if (reduced) {
-        status = cuOptGetReducedCosts(solution, reduced);
-        if (status == CUOPT_SUCCESS) {
+        cuopt_int_t reduced_status = cuOptGetReducedCosts(solution, reduced);
+        if (reduced_status == CUOPT_SUCCESS) {
             printf("x ReducedCost = %f, y ReducedCost = %f, z ReducedCost = %f\n",
                    reduced[0], reduced[1], reduced[2]);
+        } else {
+            printf("Warning: could not retrieve reduced costs: %d\n", reduced_status);
         }
         free(reduced);
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-c/assets/lp_duals/lp_duals.c around lines
85 - 109, The code overwrites the solver `status` when calling
cuOptGetDualSolution and cuOptGetReducedCosts, masking earlier failures; change
to use separate local status variables (e.g., status_dual and status_reduced)
for those post-solve queries, only log or handle their errors independently, and
keep the original `status` returned by the solver (used in the final return
expression). Update the calls to cuOptGetDualSolution and cuOptGetReducedCosts
to store results in status_dual/status_reduced and conditionally print based on
those, leaving `status` (from the solve) unchanged so the function return
reflects the actual solve result.

.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py (1)

38-39: Consider adding a timeout to the HTTP download.

urllib.request.urlretrieve can hang indefinitely on network issues. For robustness, consider using urllib.request.urlopen with a timeout.

♻️ Suggested improvement

-    print("Downloading air05.mps from MIPLIB...")
-    urllib.request.urlretrieve(AIR05_URL, gz_file)
+    print("Downloading air05.mps from MIPLIB...")
+    with urllib.request.urlopen(AIR05_URL, timeout=60) as response:
+        with open(gz_file, "wb") as out_file:
+            out_file.write(response.read())

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py around
lines 38 - 39, Replace the blocking urllib.request.urlretrieve call with a
bounded download using urllib.request.urlopen(AIR05_URL, timeout=...) and stream
the response into gz_file; locate the call where AIR05_URL is used and gz_file
is written (the print + urllib.request.urlretrieve lines) and change it to open
the URL with a timeout, read in chunks and write to gz_file, ensuring the
response and file are properly closed (use context managers) and surface/handle
timeout or HTTP errors appropriately.

.github/skills/cuopt-lp-milp-api-c/assets/lp_duals/lp_duals.c (1)

1-4: Missing SPDX license header for consistency.

Unlike lp_simple.c, this file is missing the SPDX license header. For consistency across all example assets and compliance, add the standard NVIDIA copyright and Apache-2.0 license header.

Suggested fix

 /*
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
  * LP with dual values and reduced costs (C API).
  * Problem: Minimize 3x + 2y + 5z subject to x + y + z = 4, 2x + y + z = 5, x,y,z >= 0.
  */

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-c/assets/lp_duals/lp_duals.c around lines 1
- 4, Add the missing SPDX license header at the top of lp_duals.c to match
lp_simple.c: insert the standard NVIDIA copyright and Apache-2.0 SPDX header as
the first lines of the file (above the existing block comment "LP with dual
values and reduced costs (C API).") so the file begins with the same SPDX header
text used across the example assets for consistency and compliance.

.github/skills/cuopt-lp-milp-api-c/assets/mps_solver/mps_solver.c (1)

80-95: Consider reporting malloc failure.

If malloc returns NULL, the primal solution is silently skipped. For a more informative example, consider logging the failure.

Optional improvement

     primal = malloc((size_t)num_variables * sizeof(cuopt_float_t));
-    if (primal) {
+    if (!primal) {
+        fprintf(stderr, "Warning: Failed to allocate memory for primal solution\n");
+    } else {
         status = cuOptGetPrimalSolution(solution, primal);

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-c/assets/mps_solver/mps_solver.c around
lines 80 - 95, The code currently skips reporting when
malloc((size_t)num_variables * sizeof(cuopt_float_t)) returns NULL; update the
block around primal allocation (variable primal) to check for NULL and log an
error (e.g., fprintf(stderr, "Failed to allocate primal buffer of %zu bytes\n",
(size_t)num_variables * sizeof(cuopt_float_t))) and then handle the failure
consistently (free nothing and goto cleanup or set an error status) before
attempting cuOptGetPrimalSolution; keep the existing cuOptGetPrimalSolution,
printing and free logic unchanged for the non-NULL case.

.github/skills/cuopt-routing-api-python/resources/examples.md (1)

31-31: Consider adding a brief comment explaining dtype specification.

Since this is a documentation file meant to teach users, consider adding a brief inline comment explaining why dtype="int32" is specified, especially if it's required by the API or recommended for performance reasons.

📝 Suggested documentation enhancement

 # Order data (customers 1-5)
-order_locations = cudf.Series([1, 2, 3, 4, 5], dtype="int32")  # Location indices for orders
+order_locations = cudf.Series([1, 2, 3, 4, 5], dtype="int32")  # Location indices (int32 required by API)

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-routing-api-python/resources/examples.md at line 31,
Add a short inline comment next to the order_locations = cudf.Series(...,
dtype="int32") example explaining why dtype="int32" is chosen (e.g., required by
the API for index matching and/or recommended for
memory/performance/compatibility with downstream C++/GPU operations), so readers
understand the dtype requirement or recommendation when creating order location
series.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py (2)

84-86: ⚠️ Potential issue | 🔴 Critical

Invoke Problem methods instead of storing/printing bound method objects.

Line 84, Line 85, Line 86, and Line 105-Line 108 currently use method references, not values. This can break at Line 171-Line 175 and Line 276-Line 281 when arithmetic/formatting expects numbers/bools.

Proposed fix

-    print(f"Variables: {problem.NumVariables}")
-    print(f"Constraints: {problem.NumConstraints}")
-    print(f"Is MIP: {problem.IsMIP}")
+    print(f"Variables: {problem.NumVariables()}")
+    print(f"Constraints: {problem.NumConstraints()}")
+    print(f"Is MIP: {problem.IsMIP()}")
@@
-            "objective": problem.ObjValue,
-            "num_variables": problem.NumVariables,
-            "num_constraints": problem.NumConstraints,
-            "is_mip": problem.IsMIP,
+            "objective": problem.ObjValue(),
+            "num_variables": problem.NumVariables(),
+            "num_constraints": problem.NumConstraints(),
+            "is_mip": problem.IsMIP(),

#!/bin/bash
set -euo pipefail

# Verify cuOpt Problem API definitions are methods
rg -n -C2 'def (NumVariables|NumConstraints|IsMIP|ObjValue)\(' python/cuopt/cuopt/linear_programming/problem.py

# Verify callsites in this skill file (should use parentheses)
rg -n -C2 'NumVariables|NumConstraints|IsMIP|ObjValue' .github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py

Also applies to: 105-108

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py around
lines 84 - 86, The prints and later uses are referencing bound method objects
instead of calling them — update all occurrences to call the Problem accessor
methods (e.g., use problem.NumVariables(), problem.NumConstraints(),
problem.IsMIP(), and problem.ObjValue() where referenced) so numeric/bool values
are used in arithmetic/formatting; search for usages of NumVariables,
NumConstraints, IsMIP, and ObjValue in model.py and replace the property
references with method invocations (retain existing formatting/log messages).

---

120-122: ⚠️ Potential issue | 🟠 Major

Avoid swallowing all variable-extraction failures.

Line 120-Line 122 catches Exception and silently ignores it, which hides real bugs and produces silently incomplete solutions.

Proposed fix

-        except (AttributeError, Exception):
-            # For MPS problems, variable access may be limited
-            pass
+        except AttributeError:
+            if verbose:
+                print("Variable values are unavailable for this MPS-loaded problem.")

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py around
lines 120 - 122, The current try/except block in model.py that uses "except
(AttributeError, Exception): pass" swallows all errors; change it so only
AttributeError is silently ignored (keep "except AttributeError: pass") and
handle other exceptions explicitly by capturing them (e.g., "except Exception as
e:") and logging the exception with context via the module/class logger (use
logger.exception or logger.error with the exception) and then re-raise the
exception so real bugs are not hidden; update the try/except surrounding the
variable-extraction logic (the block currently using "except (AttributeError,
Exception): pass") accordingly.

.github/skills/cuopt-lp-milp-api-c/assets/mps_solver/mps_solver.c (1)

28-32: ⚠️ Potential issue | 🟡 Minor

Route cuOptReadProblem failures through shared cleanup.

Line 31 returns early and skips the cleanup block used everywhere else. Keep failure handling consistent and jump to cleanup here too.

Suggested patch

     cuopt_int_t status = cuOptReadProblem(filename, &problem);
     if (status != CUOPT_SUCCESS) {
-        printf("Error reading MPS file: %d\n", status);
-        return 1;
+        fprintf(stderr, "Error reading MPS file: %d\n", status);
+        goto cleanup;
     }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-c/assets/mps_solver/mps_solver.c around
lines 28 - 32, The early return after calling cuOptReadProblem(...) skips the
shared cleanup block; replace the direct return with a jump to the common
cleanup path: capture the error in the existing status variable (or set an int
retval = 1), log the error as currently done, then goto cleanup so that the
problem object and other resources are freed consistently; update cleanup to
return retval (or status) at the end. Ensure changes reference cuOptReadProblem,
status, problem, filename and the existing cleanup label/block.

.github/skills/cuopt-lp-milp-api-c/assets/lp_duals/lp_duals.c (1)

78-79: Consider adding error messages for malloc failures.

When malloc returns NULL at lines 78, 90, or 100, the code silently continues without any diagnostic message. This is inconsistent with the error handling pattern elsewhere in the file. For an example/educational asset, explicit failure messages help users diagnose issues.

Optional: Add malloc failure messages

     cuopt_float_t *primal = malloc((size_t)num_variables * sizeof(cuopt_float_t));
-    if (primal) {
+    if (!primal) {
+        printf("Warning: could not allocate memory for primal solution\n");
+    } else {
         status = cuOptGetPrimalSolution(solution, primal);

Apply similar pattern to dual and reduced allocations.

Also applies to: 90-91, 100-101

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-c/assets/lp_duals/lp_duals.c around lines
78 - 79, When malloc for primal, dual, or reduced returns NULL (checks around
the pointers primal, dual, reduced), add explicit error messages and proper
cleanup/return like the other error paths in lp_duals.c: log a descriptive error
(including which allocation failed and the requested size/num variables if
available) and free any previously allocated buffers before returning an error
code or NULL; update the malloc checks for primal, dual, and reduced to follow
this pattern so failures are not silent.

.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py (1)

161-163: Use _ for the unused tuple item in compare_gaps.

problem is unpacked but not used in this block.

Proposed fix

-        problem, solution = solve_mps(
+        _, solution = solve_mps(
             filepath=filepath, time_limit=time_limit, mip_gap=gap, verbose=True
         )

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In @.github/skills/cuopt-lp-milp-api-python/assets/mps_solver/model.py around
lines 161 - 163, The tuple returned by solve_mps is being unpacked as "problem,
solution" in compare_gaps but "problem" is never used; change the unpack to "_,
solution = solve_mps(...)" inside the compare_gaps function (the call that
passes filepath, time_limit, mip_gap=gap, verbose=True) so the unused value is
clearly ignored and lint warnings are avoided.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

ci/test_skills_assets.sh (1)

54-54: Remove dead assignment (binary) to keep lint clean.

binary is set at line 54 but never used, triggering ShellCheck SC2034. The assignment can be safely removed.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@ci/test_skills_assets.sh` at line 54, The assignment to the variable "binary"
(binary="${dir}/${base}") is unused and triggers ShellCheck SC2034; remove that
line from the script so the temporary variable is not set, leaving any
subsequent logic to use "dir" and "base" directly or their existing computed
values; ensure no other references to "binary" exist elsewhere (e.g., in
functions or later commands) before removing.

.github/skills/cuopt-lp-milp-api-python/assets/milp_basic/incumbent_callback.py (1)

21-25: Mark unused callback arguments to satisfy linting.

The solution_bound and user_data parameters (line 21) are required by the GetSolutionCallback interface but not used in this implementation. Prefix them with _ to make this intentional and avoid linter warnings.

Suggested fix

-    def get_solution(self, solution, solution_cost, solution_bound, user_data):
+    def get_solution(self, solution, solution_cost, _solution_bound, _user_data):

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In
@.github/skills/cuopt-lp-milp-api-python/assets/milp_basic/incumbent_callback.py
around lines 21 - 25, Rename the unused parameters in get_solution to mark them
intentionally unused to satisfy linters: change the parameter names
solution_bound and user_data to _solution_bound and _user_data in the
get_solution method signature (keeping the method name get_solution and other
parameter names unchanged) so the callback still matches the GetSolutionCallback
interface while avoiding unused-argument warnings.

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro